using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using System;
public class IdleState : MonoBehaviour
{

}


//等待  -- patrol 巡逻状态  ： 进入一个状态点
public class Patrol : Istate
{


    public bool isback;
    public FSM message;
    //属性
    public Attribute attribute;
    //巡逻的点
    public LoopPath[] loopPaths;
    //下一个点的id
    private int Id;
    //当前在循环的哪个点
    public Transform nowtarget;

    public Patrol(FSM fsm) {
        this.message = fsm;
        nowtarget = fsm.gameObject.transform;
        this.attribute = fsm.attribute;
        this.loopPaths = fsm.loopPaths;
    }

    public void OnEnter()
    {
        attribute.point = 3;
        //换回起点，不对，不能换回去
      //  nowtarget.position = loopPaths[0].Poitn.position;
        //巡逻消耗一个点数，行动点数：AccountPoint，每次巡逻到一个点，消耗一个点数
        //形成一个循环，滴0个点的速度   距离/时间  =速度
        //在巡逻的过程中，可能进入追踪模式

        //几个点之间//用动画来做，很简单
                                                // 1 
        //我当时应该是设置了两个点：             A  <------->  B  计算每个点之间的速度 路程/时间= 速度  

        //如果说，已经计算好了速度，那就不需要重新计算，清零了


        if( loopPaths[0].Speed==Vector3.zero){

            
        loopPaths[0].Speed =  (loopPaths[loopPaths.Length-1].Poitn.position - loopPaths[0].Poitn.position)/loopPaths[0].MoveTime;

        }


        //假设我到了b点了，切换为
        Color color = new Color(229, 255, 0, 141);
        attribute.stateIcon.sprite= attribute.stateIconSprites[0];


        //有办法了 吗 ？  2-17很明显，没有

        //  1  ，2 速度都是（1）
        //计算出每 两个点之间的速度
        for (int i = 1; i < loopPaths.Length; i++)
        {
            //计算速度
            //没有计算初始第一点之间的速度

             if( loopPaths[i].Speed== Vector3.zero)
            {
                 loopPaths[i].Speed = (loopPaths[i].Poitn.position - loopPaths[i - 1].Poitn.position) / loopPaths[i].MoveTime;
             }
          
        //只有在，敌人回合，才能进行移动操作

            DebugEX.Log(loopPaths[i]);
            //巡逻也会减少点数
        }

    }


    //重新计算速度 -按照巡逻的路径进行返回
    public void againBack(){

            //速度取反 时间恢复，速度取反
            for(int i=0;i<loopPaths.Length;i++){
                loopPaths[i].Speed=-loopPaths[i].Speed; 
                loopPaths[i].MoveTime = loopPaths[i].initMoveTime;
                loopPaths[i].WaitTime =loopPaths[i].initWaitTime;
            }

    }

    //减少行动点数
    public void ReducePoint(int num ){

        if(attribute.point>0){
            attribute.point-=num;
        }else{
            //剩余点数归零 停止行动，等待所有敌人都清零，进入玩家回合
            //减少可行动的敌人总数

            Debug.Log("执行真正的减少");
           GameManger.Instance.reducePoint();
           
        }

    }


    public void OnExit()
    {
       // ("退出巡逻模式");
    }

    public void OnUpdate()
    {
        
        

        if (Id < loopPaths.Length)
        {
            LoopPath p = loopPaths[Id];
            //当移动的时间大于0时让物体向下一个点移动 等待时间
            if (p.MoveTime > 0)
            {
                p.MoveTime -= Time.deltaTime;
                //移动的时间逐步减少，移动的位置自然就
                nowtarget.position += p.Speed * Time.deltaTime;
            }
            else
            {
                //当等待的时间大于0时，物体停止不动等待时间归零
               // nowtarget.position = p.Poitn.position;
                if (p.WaitTime > 0)
                {
                    p.WaitTime -= Time.deltaTime;
                }
                else
                {
                  
                    Id++;
                   // Debug.Log("ID:" + Id+ "   "+ loopPaths.Length);
                    if (Id == loopPaths.Length-1) {
                        Id = 0;
                        //原本的速度要取反值
                        //减少点数

                        int v = message.ReducePointAft(message.ReducePoint);

                        if (v == 0) {
                            //转换为站立状态
                            message.TransitionState(StateType.Stand);
                        }

                        againBack();
                        //是因为没有重新计算速度

                    }
                   

                }
            }

        }
        




        


    }
}






//攻击状态 
public class Att : Istate
{
    public FSM message;
    public Attribute attribute;

    public Att(FSM fsm)
    {
        this.message = fsm;
        this.attribute = fsm.attribute;

    }
    public bool isAtt;

    public void OnEnter()
    {
        //如果还有剩余的点数，就执行攻击操作
        attribute.stateIcon.sprite = attribute.stateIconSprites[2];

        isAtt = false;

        //进入攻击状态
        // throw new System.NotImplementedException();
    }

    public void OnExit()
    {
        //throw new System.NotImplementedException();
    }

    public void OnUpdate()
    {




        if (attribute.point > 0 &&!isAtt)
        {

           // Debug.Log("攻击了没有啊");
            isAtt = true;


            //TODO：播放动画 敌人的武器呢 Miss呢
            Player.Instance.ReduceHP(1);
            Vector2 swing = message.transform.position + (Player.Instance.transform.position - message.transform.position) * 0.3f;
            Tweener tweener = message.transform.DOLocalMove(swing, 0.3f);
            tweener.SetLoops(2, LoopType.Yoyo);
            tweener.Play();
            tweener.OnComplete(delegate {

                int v = message.ReducePointAft(message.ReducePoint);
                if (v != 0)
                {

                    isAtt = false;
                }

            });

            //攻击一下，减少一点
            

            
           

        }

        // throw new System.NotImplementedException();
    }
}



/// <summary>
/// 追踪模式
/// </summary>
public class Track : Istate
{


    public FSM message;
    public Attribute attribute;

    // 完成寻路的坐标
    private List<Vector2> distancePointList;
    //当前移动到的点坐标
    private int nowPoint=0;
    //移动的时间
    float MoveTime = 1f;
    //每个点等待的时间
    float WaitTime = 0.5f;
    //初始FSM状态
    Vector3 initMessage;

    public Track(FSM fsm)
    {

        distancePointList = new List<Vector2>();
        nowPoint = 0;
        WaitTime = 0.5f;
        MoveTime = 1f;
        this.message = fsm;
        this.attribute = fsm.attribute;

    }

    public void OnEnter()
    {


        Color color = new Color(255, 0, 0, 103);
        attribute.stateIcon.sprite = attribute.stateIconSprites[1];

        nowPoint = 0;
        WaitTime = 0.5f;
        MoveTime = 1f;
        distancePointList.Clear();

        attribute.point = 3;
        Debug.Log(message);
        //被锁定
        Player.Instance.LockedEmeny=message.gameObject;

        //开始导航寻路
        distancePointList = message.transform.GetComponent<Routing>().StartRouting();//进入寻路模式
        initMessage=message.transform.position;
       // throw new System.NotImplementedException();
    }

    public void OnExit()
    {
       // throw new System.NotImplementedException();
    }



    public void OnUpdate() {



    
        if (distancePointList != null && nowPoint< distancePointList.Count+1 && distancePointList.Count!=0){
            //没有点数
            if(attribute.point<=0){
                //Debug.Log("切换战立状态");
               message.TransitionState(StateType.Stand);
                return;
            }

            Vector3 direction;

            if (nowPoint == 0)
            {
                 direction = distancePointList[nowPoint] - new Vector2(initMessage.x, initMessage.y);
            }
            else {
                 direction = distancePointList[nowPoint] - distancePointList[nowPoint-1];
            }
            //
            if (0<MoveTime){ 

                //当前这个点，到下个点的距离差
                MoveTime-=Time.deltaTime;

               // Debug.Log("路程和时间：："+ MoveTime +"   "+ direction);

                message.transform.position += Time.deltaTime  * direction*1;
            }
            else{
                //移动到下一个点，之前先等待一段时间，
                //因为我着是一个一个移动的，不需要单独计算速度
                if (0 < WaitTime)
                {
                    //等待时间归零
                    WaitTime -= Time.deltaTime;

                }
                else
                {
                    //开始移动，减少点数
                    Debug.Log("减少点数了吗");
                    message.ReducePoint();
                    WaitTime = 0.5f;
                    MoveTime = 1f;

                    //到达寻路终点
                    if (nowPoint < distancePointList.Count-1)
                    {
                        nowPoint++;
                       
                    }
                    else {

                        if (attribute.point > 0 ) {

                            message.TransitionState(StateType.Att);

                        }
                    
                    }

                    //已经到达终点了，看一下是否还存在点数

                  
                   
                }
             }



            

       }


        if(distancePointList.Count==0&&attribute.point>0){
            //进入攻击状态
            message.TransitionState(StateType.Att);

        }

        

    
    }


}



//站立状态，这个是一个中间的状态，在玩家回合的时候，进入到这个等待状态，转回敌人状态时，用词状态判断，是进攻还是巡逻
public  class Stand: Istate{
    public FSM message;
    public Attribute attribute;
    public Stand(FSM fsm)
    {
        this.message = fsm;
        this.attribute = fsm.attribute;
    }



    //进入状态执行
    public void OnEnter()
    {
        //中间的一个状态，用来决定是进入巡逻还是追踪

        attribute.point = 3;
      
        if (GameManger.Instance.round.Equals(GameManger.Round.player)) {
            return;
        
        }

        float radius = 4;

        float dis = Vector3.Distance(Player.Instance.transform.position, message.gameObject.transform.position);

        Debug.Log("距离："+dis);

        if (dis <= radius)
        {
            //从巡逻状态，切换为

            if (dis > 1 && Player.Instance.LockedEmeny == null)
            {
                //当切换到追踪状态的时候，要考虑到，该玩家是否已经被其他人追
                Debug.Log("距离：追踪 " + dis);
                message.TransitionState(StateType.Track);
            }
            else if (dis <= 1)
            {
                Debug.Log("距离：攻击" + dis);
                message.TransitionState(StateType.Att);
            }
        }
        else {
            message.TransitionState(StateType.Patrol);

        }
        


        //
      //  attribute.point = 3;
     //   Debug.Log("进入站立的状态，不做任何事情");
            //播放站立动画啥的
       // Debug.Log(message);
     //   Debug.Log("方向 0.1");

        //开始导航寻路
       // distancePointList = message.transform.GetComponent<Routing>().StartRouting();//进入寻路模式
      //  Debug.Log("路程点："+ distancePointList.Count);

        //站立撞他，不做任何事情

       // throw new System.NotImplementedException();
    }
    //退出状态时执行
    public void OnExit()
    {
       // throw new System.NotImplementedException();


    }


    //在此状态持续执行
    public void OnUpdate() {
        //D
       
    }

}